home *** CD-ROM | disk | FTP | other *** search
/ Inside Multimedia 1994 April / Inside Multimedia CD-ROM (April 1994).iso / prg / gs / gssource.exe / GDEVPBM.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-24  |  10.7 KB  |  349 lines
  1. /* Copyright (C) 1992 Aladdin Enterprises.  All rights reserved.
  2.    Distributed by Free Software Foundation, Inc.
  3.  
  4. This file is part of Ghostscript.
  5.  
  6. Ghostscript is distributed in the hope that it will be useful, but
  7. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  8. to anyone for the consequences of using it or for whether it serves any
  9. particular purpose or works at all, unless he says so in writing.  Refer
  10. to the Ghostscript General Public License for full details.
  11.  
  12. Everyone is granted permission to copy, modify and redistribute
  13. Ghostscript, but only under the conditions described in the Ghostscript
  14. General Public License.  A copy of this license is supposed to have been
  15. given to you along with Ghostscript so you can know your rights and
  16. responsibilities.  It should be in a file named COPYING.  Among other
  17. things, the copyright notice and this notice must be preserved on all
  18. copies.  */
  19.  
  20. /* gdevpbm.c */
  21. /* Portable Bit/Gray/PixMap devices for Ghostscript. */
  22. #include "gdevprn.h"
  23. #include "gxlum.h"
  24.  
  25. /* Thanks are due to Jos Vos (jos@bull.nl) for an earlier P*M driver, */
  26. /* on which this one is based. */
  27.  
  28. /* Structure for P*M devices, which extend the generic printer device. */
  29.  
  30. #define MAX_COMMENT 70            /* max user-supplied comment */
  31. struct gx_device_pbm_s {
  32.     gx_device_common;
  33.     gx_prn_device_common;
  34.     /* Additional state for P*M devices */
  35.     const char *magic;        /* "Pn" */
  36.     char comment[MAX_COMMENT + 1];    /* comment for head of file */
  37.     byte is_raw;            /* 1 if raw format, 0 if plain */
  38.     byte is_pbm;            /* 1 if bitmap, 0 if gray or pixmap */
  39. };
  40. typedef struct gx_device_pbm_s gx_device_pbm;
  41.  
  42. /* ------ The device descriptors ------ */
  43.  
  44. /*
  45.  * Standard U.S. page width and height.  A4 paper is 8.4" x 11.7".
  46.  */
  47. #define WIDTH_10THS 85
  48. #define HEIGHT_10THS 110
  49.  
  50. /*
  51.  * Default X and Y resolution.
  52.  */
  53. #define X_DPI 72
  54. #define Y_DPI 72
  55.  
  56. /* Macro for generating P*M device descriptors. */
  57. #define pbm_prn_device(procs, dev_name, magic, is_raw, num_comp, depth, max_gray, max_rgb, print_page)\
  58. {    prn_device_body(gx_device_pbm, procs, dev_name,\
  59.       WIDTH_10THS, HEIGHT_10THS, X_DPI, Y_DPI,\
  60.       0, 0, 0, 0,\
  61.       num_comp, depth, max_gray, max_rgb, max_gray + 1, max_rgb + 1,\
  62.       print_page),\
  63.     magic,\
  64.      { 0 },\
  65.     is_raw,\
  66.     (depth == 1)\
  67. }
  68.  
  69. /* For all PBM variants we do some extra things at opening time. */
  70. /* private dev_proc_open_device(gdev_pbm_open); */
  71. #define gdev_pbm_open gdev_prn_open        /* no we don't! */
  72.  
  73. /* For PGM and PPM we need our own color mapping procedures. */
  74. private dev_proc_map_rgb_color(pgm_map_rgb_color);
  75. private dev_proc_map_rgb_color(ppm_map_rgb_color);
  76. private dev_proc_map_color_rgb(pgm_map_color_rgb);
  77. private dev_proc_map_color_rgb(ppm_map_color_rgb);
  78.  
  79. /* And of course we need our own print-page routines. */
  80. private dev_proc_print_page(pbm_print_page);
  81. private dev_proc_print_page(pbm_raw_print_page);
  82. private dev_proc_print_page(pgm_print_page);
  83. private dev_proc_print_page(ppm_print_page);
  84.  
  85. /* The device procedures */
  86. private gx_device_procs pbm_procs =
  87.     prn_procs(gdev_pbm_open, gdev_prn_output_page, gdev_prn_close);
  88. private gx_device_procs pgm_procs =
  89.     prn_color_procs(gdev_pbm_open, gdev_prn_output_page, gdev_prn_close,
  90.     pgm_map_rgb_color, pgm_map_color_rgb);
  91. private gx_device_procs ppm_procs =
  92.     prn_color_procs(gdev_pbm_open, gdev_prn_output_page, gdev_prn_close,
  93.     ppm_map_rgb_color, ppm_map_color_rgb);
  94.  
  95. /* The device descriptors themselves */
  96. gx_device_pbm gs_pbm_device =
  97.   pbm_prn_device(pbm_procs, "pbm", "P1", 0, 1, 1, 1, 0,
  98.       pbm_print_page);
  99. gx_device_pbm gs_pbmraw_device =
  100.   pbm_prn_device(pbm_procs, "pbmraw", "P4", 1, 1, 1, 1, 1,
  101.       pbm_raw_print_page);
  102. gx_device_pbm gs_pgm_device =
  103.   pbm_prn_device(pgm_procs, "pgm", "P2", 0, 1, 8, 255, 0,
  104.       pgm_print_page);
  105. gx_device_pbm gs_pgmraw_device =
  106.   pbm_prn_device(pgm_procs, "pgmraw", "P5", 1, 1, 8, 255, 0,
  107.       pgm_print_page);
  108. gx_device_pbm gs_ppm_device =
  109.   pbm_prn_device(ppm_procs, "ppm", "P3", 0, 3, 24, 255, 255,
  110.       ppm_print_page);
  111. gx_device_pbm gs_ppmraw_device =
  112.   pbm_prn_device(ppm_procs, "ppmraw", "P6", 1, 3, 24, 255, 255,
  113.       ppm_print_page);
  114.  
  115. /* ------ Color mapping routines ------ */
  116.  
  117. /* Map an RGB color to a PGM gray value. */
  118. private gx_color_index
  119. pgm_map_rgb_color(gx_device *dev, ushort r, ushort g, ushort b)
  120. {    /* We round the value rather than truncating it. */
  121.     return ((r * (ulong)lum_red_weight) +
  122.         (g * (ulong)lum_green_weight) +
  123.         (b * (ulong)lum_blue_weight) +
  124.         (lum_all_weights / 2))
  125.            / lum_all_weights * dev->color_info.max_gray / gx_max_color_value;
  126. }
  127.  
  128. /* Map a PGM gray value back to an RGB color. */
  129. private int
  130. pgm_map_color_rgb(gx_device *dev, gx_color_index color, ushort prgb[3])
  131. {    gx_color_value gray =
  132.         color * gx_max_color_value / dev->color_info.max_gray;
  133.     prgb[0] = gray;
  134.     prgb[1] = gray;
  135.     prgb[2] = gray;
  136.     return 0;
  137. }
  138.  
  139. /* Map an RGB color to a PPM color tuple. */
  140. private gx_color_index
  141. ppm_map_rgb_color(gx_device *dev, ushort r, ushort g, ushort b)
  142. {    ushort bitspercolor = dev->color_info.depth / 3;
  143.     ulong max_value = (1 << bitspercolor) - 1;
  144.     return ((r * max_value / gx_max_color_value) << (bitspercolor * 2)) +
  145.            ((g * max_value / gx_max_color_value) << bitspercolor) +
  146.            (b * max_value / gx_max_color_value);
  147. }
  148.  
  149. /* Map a PPM color tuple back to an RGB color. */
  150. private int
  151. ppm_map_color_rgb(gx_device *dev, gx_color_index color, ushort prgb[3])
  152. {    ushort bitspercolor = dev->color_info.depth / 3;
  153.     ushort colormask = (1 << bitspercolor) - 1;
  154.  
  155.     prgb[0] = ((color >> (bitspercolor * 2)) & colormask) *
  156.         (ulong)gx_max_color_value / colormask;
  157.     prgb[1] = ((color >> bitspercolor) & colormask) *
  158.         (ulong)gx_max_color_value / colormask;
  159.     prgb[2] = (color & colormask) *
  160.         (ulong)gx_max_color_value / colormask;
  161.     return 0;
  162. }
  163.  
  164. /* ------ Internal routines ------ */
  165.  
  166. /* Define a "cursor" that keeps track of where we are in the page. */
  167. typedef struct pbm_cursor_s {
  168.     gx_device_pbm *dev;
  169.     int bpp;            /* bits per pixel */
  170.     uint line_size;            /* bytes per scan line */
  171.     byte *data;            /* output row buffer */
  172.     int lnum;            /* row within page */
  173. } pbm_cursor;
  174.  
  175. /* Begin a P*M output page. */
  176. /* Write the header information and initialize the cursor. */
  177. private int
  178. pbm_begin_page(gx_device_pbm *bdev, FILE *pstream, pbm_cursor _ss *pcur)
  179. {    uint line_size =
  180.         gdev_prn_bytes_per_scan_line((gx_device_printer *)bdev);
  181.     byte *data = (byte *)gs_malloc(line_size, 1, "pbm_begin_page");
  182.     if ( data == 0 )
  183.         return_error(gs_error_VMerror);
  184.     fprintf(pstream, "%s\n", bdev->magic);
  185.     if ( bdev->comment[0] )
  186.         fprintf(pstream, "# %s\n", bdev->comment);
  187.     else
  188.         fprintf(pstream, "# Image generated by Ghostscript (device=%s)\n",
  189.             bdev->dname);
  190.     fprintf(pstream, "%d %d\n", bdev->width, bdev->height);
  191.     if ( !bdev->is_pbm )
  192.         fprintf(pstream, "%d\n", bdev->color_info.max_gray);
  193.     /* Initialize the cursor. */
  194.     pcur->dev = bdev;
  195.     pcur->bpp = bdev->color_info.depth;
  196.     pcur->line_size = line_size;
  197.     pcur->data = data;
  198.     pcur->lnum = 0;
  199.     return 0;
  200. }
  201.  
  202. /* Advance to the next row.  Return 0 if more, 1 if done. */
  203. private int
  204. pbm_next_row(pbm_cursor _ss *pcur)
  205. {    if ( pcur->lnum >= pcur->dev->height )
  206.        {    gs_free((char *)pcur->data, pcur->line_size, 1,
  207.             "pbm_next_row(done)");
  208.         return 1;
  209.        }
  210.     gdev_prn_copy_scan_lines((gx_device_printer *)pcur->dev,
  211.                  pcur->lnum++, pcur->data, pcur->line_size);
  212.     return 0;
  213. }
  214.  
  215. /* ------ Individual page printing routines ------ */
  216.  
  217. #define bdev ((gx_device_pbm *)pdev)
  218.  
  219. /* Print a raw monobit page. */
  220. private int
  221. pbm_raw_print_page(gx_device_printer *pdev, FILE *pstream)
  222. {    /* All the print_page routines have the same structure; */
  223.     /* only the indicated section is different. */
  224.     pbm_cursor cur;
  225.     int code = pbm_begin_page(bdev, pstream, &cur);
  226.     if ( code < 0 ) return code;
  227.     while ( !(code = pbm_next_row(&cur)) )
  228.        {
  229.         /* ---- This section changes. ---- */
  230.  
  231.         fwrite(cur.data, 1, cur.line_size, pstream);
  232.  
  233.         /* ---- End of changing section. ---- */
  234.        }
  235.     return (code < 0 ? code : 0);
  236. }
  237.  
  238. /* Print an ASCII monobit page. */
  239. private int
  240. pbm_print_page(gx_device_printer *pdev, FILE *pstream)
  241. {    pbm_cursor cur;
  242.     int code = pbm_begin_page(bdev, pstream, &cur);
  243.     if ( code < 0 ) return code;
  244.     while ( !(code = pbm_next_row(&cur)) )
  245.        {    byte *bp;
  246.         uint x, mask;
  247.         for ( bp = cur.data, x = 0, mask = 0x80; x < bdev->width;
  248.               (mask >>= 1) != 0 || (bp++, mask = 0x80)
  249.             )
  250.            {    putc((*bp & mask ? '1' : '0'), pstream);
  251.             if ( ++x == bdev->width || !(x & 63) )
  252.                 putc('\n', pstream);
  253.            }
  254.        }
  255.     return (code < 0 ? code : 0);
  256. }
  257.  
  258. /* Print a gray-mapped page. */
  259. private int
  260. pgm_print_page(gx_device_printer *pdev, FILE *pstream)
  261. {    pbm_cursor cur;
  262.     int code = pbm_begin_page(bdev, pstream, &cur);
  263.     uint mask;
  264.     if ( code < 0 ) return code;
  265.     /* Note that bpp <= 8 for raw format, bpp <= 16 for plain. */
  266.     mask = (1 << cur.bpp) - 1;
  267.     while ( !(code = pbm_next_row(&cur)) )
  268.        {    byte *bp;
  269.         uint x;
  270.         int shift;
  271.         for ( bp = cur.data, x = 0, shift = 8 - cur.bpp;
  272.               x < bdev->width;
  273.             )
  274.            {    uint pixel;
  275.             if ( shift < 0 )    /* bpp = 16 */
  276.                {    pixel = ((uint)*bp << 8) + bp[1];
  277.                 bp += 2;
  278.                }
  279.             else
  280.                {    pixel = (*bp >> shift) & mask;
  281.                 if ( (shift -= cur.bpp) < 0 )
  282.                     bp++, shift += 8;
  283.                }
  284.             ++x;
  285.             if ( bdev->is_raw )
  286.                 putc(pixel, pstream);
  287.             else
  288.                 fprintf(pstream, "%d%c", pixel,
  289.                     (x == bdev->width || !(x & 15) ?
  290.                      '\n' : ' '));
  291.            }
  292.        }
  293.     return (code < 0 ? code : 0);
  294. }
  295.  
  296. /* Print a color-mapped page. */
  297. private int
  298. ppm_print_page(gx_device_printer *pdev, FILE *pstream)
  299. {    pbm_cursor cur;
  300.     int code = pbm_begin_page(bdev, pstream, &cur);
  301.     uint bpe, mask;
  302.     if ( code < 0 ) return code;
  303.     /* Note that bpp <= 24 for raw format, bpp <= 32 for plain. */
  304.     bpe = cur.bpp / 3;        /* bits per r/g/b element */
  305.     mask = (1 << bpe) - 1;
  306.     while ( !(code = pbm_next_row(&cur)) )
  307.        {    byte *bp;
  308.         uint x;
  309.         int shift;
  310.         for ( bp = cur.data, x = 0, shift = 8 - cur.bpp;
  311.               x < bdev->width;
  312.             )
  313.            {    ulong pixel = 0;
  314.             uint r, g, b;
  315.             switch ( cur.bpp >> 3 )
  316.                {
  317.             case 3:
  318.                 pixel = (ulong)*bp << 16; bp++;
  319.                 /* falls through */
  320.             case 2:
  321.                 pixel += (uint)*bp << 8; bp++;
  322.                 /* falls through */
  323.             case 1:
  324.                 pixel += *bp; bp++;
  325.                 break;
  326.             case 0:            /* bpp == 4, bpe == 1 */
  327.                 pixel = *bp >> shift;
  328.                 if ( (shift -= cur.bpp) < 0 )
  329.                     bp++, shift += 8;
  330.                 break;
  331.                }
  332.             ++x;
  333.             b = pixel & mask;  pixel >>= bpe;
  334.             g = pixel & mask;  pixel >>= bpe;
  335.             r = pixel & mask;
  336.             if ( bdev->is_raw )
  337.                {    putc(r, pstream);
  338.                 putc(g, pstream);
  339.                 putc(b, pstream);
  340.                }
  341.             else
  342.                 fprintf(pstream, "%d %d %d%c", r, g, b,
  343.                     (x == bdev->width || !(x & 7) ?
  344.                      '\n' : ' '));
  345.            }
  346.        }
  347.     return (code < 0 ? code : 0);
  348. }
  349.